package com.doit.day06

import com.doit.day05.Phone

//在java中就是一个 switch  if else的组合
//在sql中就是一个case when
object _05_模式匹配 {
  def main(args: Array[String]): Unit = {

    //值匹配
    val name = "jige"

    name match {
      case "lss" => println("我不是zss，我是lss")
      case "jingjing" => println("你大爷的")
      case "jige" => println("我还单身，谁来解救我")
      case "驰哥" => println("我也单身，我喜欢男的")
      case _ => println("如果上面都匹配不到，就执行我这个逻辑")
    }


    //匹配类型
    val list = List(1, "zss", true, (1, "zss"), ("zss", 1), Array((1, 2), (2, 3), (3, 4)), List(1, 2, 3), Map((1, 2), (2, 3), (3, 4)))
    for (elem <- list) {
      elem match {
        //除了正常的类型，比如int string  double ... 都是正常匹配上的
        //但是来到集合或者元祖的时候，他会进行泛型的擦除==》 Array 这个类型是正常的，泛型不会被擦除
        case a: Int => println("我是一个Int类型，我的值是" + a)
        case a: String => println("我是一个String类型，我的值是" + a)
        case a: Boolean => println("我是一个Boolean类型，我的值是" + a)
        case a: (Int, String) => println("我是一个二元元祖类型,第一个是Int,第二个是String,我的值是" + a)
        case a: Array[(String, String)] => println("我是一个数组类型，Int，我的值是" + a)
        case a: List[String] => println("我是一个List类型 String，我的值是" + a)
        case a: Map[String, String] => println("我是一个Map类型，我的值是" + a)
        case _ => println("我是垃圾回收站，谁匹配不上的就到我这来把")
      }

    }


    val str = "jingjing1"

    val res: Any = str match {
      case "wenxin" => (a: Int, b: Int) => {
        a + b + ""
      }
      case "tingting" => (a: Int, b: Int) => {
        a - b
      }
      case "yuanyuan" => (a: Int, b: Int) => {
        a * b
      }
      case "jingjing" => (a: Int, b: Int) => {
        a / b
      }
      case _ => println("扁担说什么就是什么")
    }
    val function = res.asInstanceOf[Unit]
    println(function)

    //    val function: (Int, Int) => Int = res.asInstanceOf[Function2[Int,Int,Int]]
    //    println(function.apply(10, 2))

    println("==============富婆的分割线==============")

    //匹配数组

    val arr: Array[Array[Any]] = Array(Array(1), Array(1, 2), Array(1, 2, 3), Array(1, 3, 4), Array("1", "2", 3))

    for (elem <- arr) {
      elem match {
        case Array(1, 2) => println("这个数组里面有两个元素，第一个值必须是1，第二个值必须是2")
        case Array(_, 3, _) => println("数组里面有三个元素，第一个和第三个长什么样子无所谓，但是第二个必须是3")
        case Array(1, _*) => println("数组里面至少有一个元素，第一个元素肯定是1，后面有几个元素都无所谓")
        case Array("1", _*) => println("数组里面至少有一个元素，第一个元素肯定是字符串1，后面有几个元素都无所谓")
        case _ => println("对不上的都过来")
      }
    }


    //匹配元祖
    val arr1: Array[Any] = Array((1, 2, 3), (1, 2), (1, 2, 3, 4), (1, 2, 3, 4, 5))
    for (elem <- arr1) {
      val aaa = elem match {
        case (1, _, _) => 1
        case (_, _) => 2
        case (_, _, 3) => 3
        case _ => 4
      }
      println(aaa)

    }

    //匹配对象   解构匹配
    //如果你想要匹配对象，单纯的这个类如果说只是class 类 或者只是object类 不行
    //必须是伴生类和伴生对象，并且还要实现unapply方法 case class 为什么可以直接用  因为底层给我们实现了伴生类伴生对象，并且还重写了apply和unapply
    val lions: Array[Lion] = Array(Lion(1, "zss", 18), Lion(2, "lss", 28), Lion(3, "ww", 38))
    val lions1: Array[Lion1] = Array(new Lion1(1, "zss", 18), new Lion1(2, "lss", 28), new Lion1(3, "ww", 38))
    for (elem <- lions1) {
      elem match {
        case Lion1(_, _, 18) => println("a")
        case Lion1(_, "lss", _) => println("b")
        case _ => println("c")
      }
    }


    //解构匹配的其他应用
    val map: Map[Int, String] = Map((1, "zss"), (2, "lss"))
    //elem 元祖  ==》 元祖对象给解构
    for (elem <- map) {
      val key: Int = elem._1
      val value: String = elem._2
    }


    for ((_, value) <- map) {  //代码当量
      println(value)
    }


    val (a, b) = (1, 2)
    // val a = 1
    // val b = 2


  }
}

case class Lion(id: Int, name: String, age: Int)


class Lion1(val id: Int, val name: String, val age: Int)

object Lion1 {
  //  def apply(id: Int, name: String, age: Int): Lion1 = new Lion1(id, name, age)

  def unapply(arg: Lion1): Option[(Int, String, Int)] = Some(arg.id, arg.name, arg.age)

}